home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / dummy_thread.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  5KB  |  158 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Drop-in replacement for the thread module.
  5.  
  6. Meant to be used as a brain-dead substitute so that threaded code does
  7. not need to be rewritten for when the thread module is not present.
  8.  
  9. Suggested usage is::
  10.  
  11.     try:
  12.         import thread
  13.     except ImportError:
  14.         import dummy_thread as thread
  15.  
  16. '''
  17. __author__ = 'Brett Cannon'
  18. __email__ = 'brett@python.org'
  19. __all__ = [
  20.     'error',
  21.     'start_new_thread',
  22.     'exit',
  23.     'get_ident',
  24.     'allocate_lock',
  25.     'interrupt_main',
  26.     'LockType']
  27. import traceback as _traceback
  28.  
  29. class error(Exception):
  30.     '''Dummy implementation of thread.error.'''
  31.     
  32.     def __init__(self, *args):
  33.         self.args = args
  34.  
  35.  
  36.  
  37. def start_new_thread(function, args, kwargs = { }):
  38.     '''Dummy implementation of thread.start_new_thread().
  39.  
  40.     Compatibility is maintained by making sure that ``args`` is a
  41.     tuple and ``kwargs`` is a dictionary.  If an exception is raised
  42.     and it is SystemExit (which can be done by thread.exit()) it is
  43.     caught and nothing is done; all other exceptions are printed out
  44.     by using traceback.print_exc().
  45.  
  46.     If the executed function calls interrupt_main the KeyboardInterrupt will be
  47.     raised when the function returns.
  48.  
  49.     '''
  50.     global _main, _interrupt
  51.     if type(args) != type(tuple()):
  52.         raise TypeError('2nd arg must be a tuple')
  53.     
  54.     if type(kwargs) != type(dict()):
  55.         raise TypeError('3rd arg must be a dict')
  56.     
  57.     _main = False
  58.     
  59.     try:
  60.         function(*args, **kwargs)
  61.     except SystemExit:
  62.         pass
  63.     except:
  64.         _traceback.print_exc()
  65.  
  66.     _main = True
  67.     if _interrupt:
  68.         _interrupt = False
  69.         raise KeyboardInterrupt
  70.     
  71.  
  72.  
  73. def exit():
  74.     '''Dummy implementation of thread.exit().'''
  75.     raise SystemExit
  76.  
  77.  
  78. def get_ident():
  79.     '''Dummy implementation of thread.get_ident().
  80.  
  81.     Since this module should only be used when threadmodule is not
  82.     available, it is safe to assume that the current process is the
  83.     only thread.  Thus a constant can be safely returned.
  84.     '''
  85.     return -1
  86.  
  87.  
  88. def allocate_lock():
  89.     '''Dummy implementation of thread.allocate_lock().'''
  90.     return LockType()
  91.  
  92.  
  93. class LockType(object):
  94.     '''Class implementing dummy implementation of thread.LockType.
  95.  
  96.     Compatibility is maintained by maintaining self.locked_status
  97.     which is a boolean that stores the state of the lock.  Pickling of
  98.     the lock, though, should not be done since if the thread module is
  99.     then used with an unpickled ``lock()`` from here problems could
  100.     occur from this class not having atomic methods.
  101.  
  102.     '''
  103.     
  104.     def __init__(self):
  105.         self.locked_status = False
  106.  
  107.     
  108.     def acquire(self, waitflag = None):
  109.         """Dummy implementation of acquire().
  110.  
  111.         For blocking calls, self.locked_status is automatically set to
  112.         True and returned appropriately based on value of
  113.         ``waitflag``.  If it is non-blocking, then the value is
  114.         actually checked and not set if it is already acquired.  This
  115.         is all done so that threading.Condition's assert statements
  116.         aren't triggered and throw a little fit.
  117.  
  118.         """
  119.         if waitflag is None:
  120.             self.locked_status = True
  121.             return None
  122.         elif not waitflag:
  123.             if not self.locked_status:
  124.                 self.locked_status = True
  125.                 return True
  126.             else:
  127.                 return False
  128.         else:
  129.             self.locked_status = True
  130.             return True
  131.  
  132.     
  133.     def release(self):
  134.         '''Release the dummy lock.'''
  135.         if not self.locked_status:
  136.             raise error
  137.         
  138.         self.locked_status = False
  139.         return True
  140.  
  141.     
  142.     def locked(self):
  143.         return self.locked_status
  144.  
  145.  
  146. _interrupt = False
  147. _main = True
  148.  
  149. def interrupt_main():
  150.     '''Set _interrupt flag to True to have start_new_thread raise
  151.     KeyboardInterrupt upon exiting.'''
  152.     global _interrupt
  153.     if _main:
  154.         raise KeyboardInterrupt
  155.     else:
  156.         _interrupt = True
  157.  
  158.